home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / archiver / zoo21src.zoo / portable.c < prev    next >
C/C++ Source or Header  |  1991-07-24  |  22KB  |  723 lines

  1. #ifndef LINT
  2. /* @(#) portable.c 2.24 88/08/24 01:22:06 */
  3. static char sccsid[]="@(#) portable.c 2.24 88/08/24 01:22:06";
  4. #endif /* LINT */
  5.  
  6. #include "options.h"
  7. /*
  8. Copyright (C) 1986, 1987 Rahul Dhesi -- All rights reserved
  9. (C) Copyright 1988 Rahul Dhesi -- All rights reserved
  10. */
  11. /**********************
  12. portable.c contains functions needed to make Zoo portable to various
  13. implementations of C.
  14.  
  15. Note:  Provided a 2's complement machine is used, all functions in
  16. this file are themselves machine-independent and need not be changed
  17. when implementing Zoo on a different machine.  Some code will choke
  18. on 1's complement machines--I think.  
  19.  
  20. For machine-dependent declarations see files "machine.h" and "options.h". 
  21.  
  22. For machine-dependent functions see file "machine.c"
  23. */
  24.  
  25. #include "zoo.h"
  26. #include "zooio.h"
  27.  
  28. #include "various.h"
  29. #include "zoofns.h"
  30.  
  31. #include "machine.h"
  32. #include "debug.h"
  33. #include "assert.h"
  34.  
  35. #ifdef NEEDCTYP
  36. #include <ctype.h>              /* for tolower() */
  37. #endif
  38.  
  39. #include "portable.h"
  40.  
  41. #ifdef TRACE_IO
  42. extern int verbose;
  43. #endif
  44.  
  45. /* Functions defined for use within this file only.  */
  46. long to_long PARMS((BYTE[]));
  47. int to_int PARMS((BYTE[]));
  48. void b_to_zooh PARMS((struct zoo_header *, BYTE[]));
  49. void b_to_dir PARMS((struct direntry *, BYTE[]));
  50. int dir_to_b PARMS((BYTE[], struct direntry *));
  51. void zooh_to_b PARMS((BYTE[], struct zoo_header *));
  52. void splitlong PARMS((BYTE[], long));
  53. void splitint PARMS((BYTE[], int));
  54.  
  55. #ifdef TRACE_IO
  56. void show_h PARMS ((struct zoo_header *));
  57. void show_dir PARMS ((struct direntry *));
  58. #endif /* TRACE_IO */
  59.  
  60. extern unsigned int crccode;
  61.  
  62. /************************************************************************/
  63. /* I/O functions */
  64. /************************************************************************/
  65.  
  66. /* some functions get defined only if they aren't already macros */
  67.  
  68. #ifndef zooread
  69. int zooread (file, buffer, count)
  70. ZOOFILE file; char *buffer; int count;
  71. { return (fread (buffer, 1, count, file)); }
  72. #endif /* zooread */
  73.  
  74. #ifndef FIZ
  75. #ifndef zoowrite
  76. int zoowrite (file, buffer, count)
  77. ZOOFILE file; char *buffer; int count;
  78.     if (file == NULLFILE)
  79.        return (count);
  80.     else
  81.         return (fwrite (buffer, 1, count, file)); 
  82. }
  83. #endif /* zoowrite */
  84.  
  85. ZOOFILE zoocreate (fname)
  86. char *fname;
  87. { return ((ZOOFILE) fopen (fname, Z_NEW)); }
  88.  
  89. #endif /* FIZ */
  90.  
  91. #ifndef zooseek
  92. long zooseek (file, offset, whence)
  93. ZOOFILE file; long offset; int whence;
  94. { return (fseek (file, offset, whence)); }
  95. #endif /* zooseek */
  96.  
  97. ZOOFILE zooopen (fname, option)
  98. char *fname; char *option;
  99. { return ((ZOOFILE) fopen (fname, option)); }
  100.  
  101. #ifndef zootell
  102. long zootell (file)
  103. ZOOFILE file;
  104. { return ftell (file); }
  105. #endif /* zootell */
  106.  
  107. int zooclose (file)
  108. ZOOFILE file;
  109. { return fclose (file); }
  110.  
  111. /**********************
  112. low_ch() is a macro that returns a lowercased char; it may be
  113. used with any char, whether or not it is uppercase.   It will
  114. be used below by one or two functions.
  115. */
  116.  
  117. #define low_ch(c)        (isupper(c) ? tolower(c) : c)
  118.  
  119. /************************************************************************/
  120. /*** Following are functions that make up for various implementations ***/
  121. /*** of C not having certain library routines.                        ***/
  122. /************************************************************************/
  123.  
  124. #ifndef FIZ
  125. /**********************
  126. str_lwr() converts a string to lowercase and returns a pointer to the string
  127. */
  128. char *str_lwr (str)
  129. char *str;
  130. {
  131.    register char *s;
  132.    s = str;
  133.    while (*s != '\0') {
  134.       *s = toascii(*s);
  135.         *s = low_ch(*s);
  136.       s++;
  137.    }
  138.    return (str);
  139. }
  140.  
  141. /**********************
  142. str_icmp() compares strings just like strcmp() but it does it without regard to
  143. case.
  144. */
  145. int str_icmp (s1, s2)
  146. register char *s1, *s2;
  147. {
  148.    for ( ; low_ch(*s1) == low_ch(*s2);  s1++, s2++)
  149.       if (*s1 == '\0')
  150.          return(0);
  151.    return(low_ch(*s1) - low_ch(*s2));
  152. }
  153.  
  154. #ifdef NEED_MEMSET
  155. /**********************
  156. memset() it sets the first "count" bytes of "dest" to the character
  157. "c" and returns a pointer to "dest".
  158. */
  159. VOIDPTR memset (dest, c, count)
  160. register VOIDPTR dest;
  161. int c;
  162. unsigned count;
  163. {
  164.    register unsigned i;
  165.    for (i = 0; i < count; i++) {
  166.       *((char *) (dest + i)) = c;
  167.    }
  168.    return dest;
  169. }
  170. #endif /* NEED_MEMSET */
  171.  
  172. #ifdef NEED_MEMCPY
  173. /**********************
  174. memcpy() copies "count" bytes from "src" to "dest" and returns 
  175. a pointer to "dest".  Not necessarily safe for overlapping moves. */
  176.  
  177. VOIDPTR memcpy(dest, src, count)
  178. register VOIDPTR dest;
  179. register VOIDPTR src;
  180. unsigned count;
  181. {
  182.     VOIDPTR savedest = dest;
  183.     while (count > 0) {
  184.         *((char *) dest++) = *((char *) src++);
  185.         count--;
  186.     }
  187. }
  188. #endif /* NEED_MEMCPY */
  189.  
  190. #ifndef FPUTCHAR
  191. /**********************
  192. fputchar() writes a character to stdout.  It is identical to putchar
  193. but is a function, not a macro.
  194. */
  195. int fputchar (c)
  196. int c;
  197. {
  198.    return (fputc(c, stdout));
  199. }
  200. #endif /* FPUTCHAR */
  201. #endif /* FIZ */
  202.  
  203. /***********************************************************************/
  204. /*** Following are declarations and functions that are written in a  ***/
  205. /*** machine-independent way but they implement machine-dependent    ***/
  206. /*** activities                                                      ***/
  207. /***********************************************************************/
  208.  
  209. #ifndef DIRECT_CONVERT
  210. /**********************
  211. to_long() converts four consecutive bytes, in order of increasing
  212. significance, to a long integer.  It is used to make Zoo independent of the
  213. byte order of the system.  
  214. */
  215. long to_long(data)
  216. BYTE data[];
  217. {
  218.    return (long) ((unsigned long) data[0] | ((unsigned long) data[1] << 8) |
  219.          ((unsigned long) data[2] << 16) | ((unsigned long) data[3] << 24));
  220. }
  221.  
  222. #ifndef FIZ
  223. /********************
  224. splitlong() converts a long integer to four consecutive BYTEs in order
  225. of increasing significance.
  226. */
  227. void splitlong(bytes, bigword)
  228. BYTE bytes[];
  229. long bigword;
  230. {
  231.    int i;
  232.    for (i = 0; i < 4; i++) {
  233.       bytes[i] = bigword & 0xff;
  234.       bigword = (unsigned long) bigword >> 8;
  235.    }
  236. }     
  237. #endif /* FIZ */
  238.  
  239. /*******************
  240. splitint() converts an integer to two consecutive BYTEs in order
  241. of increasing significance.
  242. */
  243. void splitint(bytes, word)
  244. BYTE bytes[];
  245. int word;
  246. {
  247.    bytes[0] = word & 0xff;
  248.    word = (unsigned int) word >> 8;
  249.    bytes[1] = word & 0xff;
  250. }
  251.  
  252. /**********************
  253. to_int() converts two consecutive bytes, in order of increasing
  254. significance, to an integer, in a machine-independent manner
  255. */
  256. int to_int(data)
  257. BYTE data[];
  258. {
  259.    return (int) ((unsigned int) data[0] | ((unsigned int) data[1] << 8));
  260. }
  261.  
  262. #else /* else of ifndef DIRECT_CONVERT */
  263.  
  264. long to_long(data)
  265. BYTE data[];
  266. {
  267.    return ( * (long *) data );
  268. }
  269.  
  270. #ifndef FIZ
  271. /********************
  272. splitlong() converts a long integer to four consecutive BYTEs in order
  273. of increasing significance.
  274. */
  275. void splitlong(bytes, bigword)
  276. BYTE bytes[];
  277. long bigword;
  278. {
  279.    * (long *) bytes = bigword;
  280. }
  281. #endif /* FIZ */
  282.  
  283. /*******************
  284. splitint() converts an integer to two consecutive BYTEs in order
  285. of increasing significance.
  286. */
  287. void splitint(bytes, word)
  288. BYTE bytes[];
  289. int word;
  290. {
  291.    * (int *) bytes = word;
  292. }
  293.  
  294. /**********************
  295. to_int() converts two consecutive bytes, in order of increasing
  296. significance, to an integer.
  297. */
  298. int to_int(data)
  299. BYTE data[];
  300. {
  301.    return (*(int *) data);
  302. }
  303.  
  304. #endif /* ifndef DIRECT_CONVERT .. else ... */
  305.  
  306. #ifndef FIZ
  307. /**********************
  308. Function frd_zooh() reads the header of a Zoo archive in a machine-
  309. independent manner, from a ZOOFILE.
  310. */
  311. int frd_zooh(zoo_header, zoo_file)
  312. struct zoo_header *zoo_header;
  313. ZOOFILE zoo_file;
  314. {
  315.    int status;
  316.    BYTE bytes[SIZ_ZOOH];         /* canonical header representation */
  317. #ifdef TRACE_IO
  318.    if (verbose) {
  319.       printf("At file position [%8lx] ", ftell(zoo_file));
  320.    }
  321. #endif
  322.    status = zooread (zoo_file, (char *) bytes, SIZ_ZOOH);
  323.    b_to_zooh (zoo_header, bytes);   /* convert array to str